/**
 * @file mysql_orm.h
 * @brief MySQL ORM辅助类 - 简化数据库操作
 * @author liyingcheng <1871304538@qq.com>
 * @date 2025-10-12
 */

#pragma once

#include "database/mysql_pool.h"
#include <nlohmann/json.hpp>
#include <vector>
#include <string>
#include <map>
#include <functional>

namespace cpp_backend
{
    namespace database
    {

        /**
         * @brief MySQL ORM - 提供便捷的CRUD操作
         */
        class MySQLORM
        {
        public:
            /**
             * @brief 查询单条记录
             * @param table 表名
             * @param condition WHERE条件（不含WHERE关键字）
             * @return JSON对象，未找到返回null
             */
            static nlohmann::json FindOne(const std::string &table,
                                          const std::string &condition);

            /**
             * @brief 查询多条记录
             * @param table 表名
             * @param condition WHERE条件（可选）
             * @param order_by 排序条件（可选）
             * @param limit 限制条数（可选，0表示不限制）
             * @return JSON数组
             */
            static nlohmann::json FindAll(const std::string &table,
                                          const std::string &condition = "",
                                          const std::string &order_by = "",
                                          int limit = 0);

            /**
             * @brief 根据ID查询
             * @param table 表名
             * @param id ID值
             * @param id_field ID字段名（默认为"id"）
             * @return JSON对象，未找到返回null
             */
            static nlohmann::json FindById(const std::string &table,
                                           int64_t id,
                                           const std::string &id_field = "id");

            /**
             * @brief 插入记录
             * @param table 表名
             * @param data 数据（JSON对象）
             * @return 插入的ID，失败返回-1
             */
            static int64_t Insert(const std::string &table,
                                  const nlohmann::json &data);

            /**
             * @brief 批量插入
             * @param table 表名
             * @param data_list 数据列表（JSON数组）
             * @return 成功插入的记录数
             */
            static int BatchInsert(const std::string &table,
                                   const nlohmann::json &data_list);

            /**
             * @brief 更新记录
             * @param table 表名
             * @param data 更新的数据（JSON对象）
             * @param condition WHERE条件
             * @return 影响的行数，失败返回-1
             */
            static int Update(const std::string &table,
                              const nlohmann::json &data,
                              const std::string &condition);

            /**
             * @brief 根据ID更新
             * @param table 表名
             * @param id ID值
             * @param data 更新的数据（JSON对象）
             * @param id_field ID字段名（默认为"id"）
             * @return 影响的行数，失败返回-1
             */
            static int UpdateById(const std::string &table,
                                  int64_t id,
                                  const nlohmann::json &data,
                                  const std::string &id_field = "id");

            /**
             * @brief 删除记录
             * @param table 表名
             * @param condition WHERE条件
             * @return 影响的行数，失败返回-1
             */
            static int Delete(const std::string &table,
                              const std::string &condition);

            /**
             * @brief 根据ID删除
             * @param table 表名
             * @param id ID值
             * @param id_field ID字段名（默认为"id"）
             * @return 影响的行数，失败返回-1
             */
            static int DeleteById(const std::string &table,
                                  int64_t id,
                                  const std::string &id_field = "id");

            /**
             * @brief 统计记录数
             * @param table 表名
             * @param condition WHERE条件（可选）
             * @return 记录数，失败返回-1
             */
            static int64_t Count(const std::string &table,
                                 const std::string &condition = "");

            /**
             * @brief 检查记录是否存在
             * @param table 表名
             * @param condition WHERE条件
             * @return 是否存在
             */
            static bool Exists(const std::string &table,
                               const std::string &condition);

            /**
             * @brief 分页查询
             * @param table 表名
             * @param page 页码（从1开始）
             * @param page_size 每页记录数
             * @param condition WHERE条件（可选）
             * @param order_by 排序条件（可选）
             * @return JSON对象，包含data和pagination信息
             */
            static nlohmann::json Paginate(const std::string &table,
                                           int page,
                                           int page_size,
                                           const std::string &condition = "",
                                           const std::string &order_by = "");

            /**
             * @brief 执行事务
             * @param callback 事务回调函数，返回true表示提交，false表示回滚
             * @return 是否成功
             */
            static bool Transaction(std::function<bool(sql::Connection *)> callback);

        private:
            /**
             * @brief JSON转SQL SET子句
             */
            static std::string JsonToSetClause(const nlohmann::json &data);

            /**
             * @brief JSON转SQL INSERT VALUES
             */
            static std::string JsonToValues(const nlohmann::json &data,
                                            std::vector<std::string> &fields);

            /**
             * @brief 转义字符串
             */
            static std::string EscapeString(const std::string &str);
        };

    } // namespace database
} // namespace file_server
